#define _CRT_SECURE_NO_WARNINGS  1
#pragma warning(disable:6031)
#include<stdlib.h>
#include<stdio.h>
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<cstring>
#include<stdbool.h>
#include<assert.h>
#include<list>
#include<set>
#include<iomanip>
#include<map>
#include<queue>
#include<unordered_map>
#include<deque>
#include<climits>
using namespace std;

//int main() {
//	string s1 = "hello word";
//	size_t s2 = s1.capacity();
//	for (size_t i = 0; i < 100; ++i) {
//		cout << s1.capacity() << endl;
//	}
//	return 0;
//}

//class SOlution {
//	int sdhiuweh(string s) {
//		int n = s.size();
//
//	}
//};

//int main() {
//	string s1 = "123456789";
//	int s2 = s1.capacity();
//	s1.resize(6);
//	cout << s2 << " " << s1.size() << endl;
//	return 0;
//}

//struct TreeNode {
//	struct Node* child;
//	struct Node* brother;
//	int data;
//};

//#include <iostream>
//#include <stdexcept>
//
//class CircularArray {
//private:
//    int* arr;
//    int head, tail, capacity, size;
//
//public:
//    CircularArray(int cap) : capacity(cap), head(0), tail(0), size(0) {
//        arr = new int[capacity];
//    }
//
//    ~CircularArray() { delete[] arr; }
//
//    bool enqueue(int val) {
//        if (isFull()) return false;
//        arr[tail] = val;
//        tail = (tail + 1) % capacity;
//        size++;
//        return true;
//    }
//
//    bool dequeue() {
//        if (isEmpty()) return false;
//        head = (head + 1) % capacity;
//        size--;
//        return true;
//    }
//
//    int front() {
//        if (isEmpty()) throw std::runtime_error("Queue is empty");
//        return arr[head];
//    }
//
//    bool isEmpty() { return size == 0; }
//    bool isFull() { return size == capacity; }
//    int getSize() { return size; }
//};
//
//int main() {
//    CircularArray cq(5);
//    cq.enqueue(10);
//    cq.enqueue(20);
//    std::cout << "Front: " << cq.front() << std::endl; // 10
//    cq.dequeue();
//    std::cout << "Front: " << cq.front() << std::endl; // 20
//    return 0;
//}

//class Solution {
//public:
//	int rob(vector<int>& nums) {
//		int n = nums.size();
//		return max(nums[0] + rob1(nums, 2, n - 2), rob1(nums, 1, n - 1));
//	}
//	int rob1(vector<int>& nums, int l, int r) {
//		if (l > r) return 0;
//		int n = nums.size();
//		vector<int> f(n);
//		auto g = f;
//		f[l] = nums[l];
//		for (int i = l + 1; i <= r; ++i) {
//			f[i] = g[i - 1] + nums[i];
//			g[i] = max(f[i - 1], g[i - 1]);
//		}
//		return max(f[r], g[r]);
//	}
//};

//class Solution {
//public:
//	int rob(vector<int>& nums) {
//		int n = nums.size();
//		return max(nums[0] + rob1(nums, 2, n - 1), rob1(nums, 1, n - 1));
//	}
//	int rob1(vector<int>& nums, int l, int r) {
//		if (l > r) return 0;
//		int n = nums.size();
//		vector<int> f(n);
//		auto g = f;
//		f[l] = g[l];
//		for (int i = l + 1; i <= r; ++i) {
//			f[i] = g[i - 1] + nums[i];
//			g[i] = max(f[i - 1], g[i - 1]);
//		}
//		return max(f[r], g[r]);
//	}
//};

//class Solution {
//public:
//    int calculateMinimumHP(vector<vector<int>>& d) {
//        int m = d.size(), n = d[0].size();
//        vector<vector<int>> dp(m + 1, vector<int>(n + 1, INT_MAX));
//        dp[m - 1][n] = dp[m][n - 1] = 1;
//        for (int i = m - 1; i >= 0; --i) {
//            for (int j = n - 1; j >= 0; --j) {
//                dp[i][j] = min(dp[i + 1][j], dp[i][j + 1]) - d[i][j];
//                dp[i][j] = max(1, dp[i][j]);
//            }
//        }
//        return dp[0][0];
//    }
//};
//
//class Solution {
//public:
//    int minPathSum(vector<vector<int>>& g) {
//        int m = g.size(), n = g[0].size();
//        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
//        dp[0][1] = dp[1][0] = 0;
//        for (int i = 1; i <= m; ++i) {
//            for (int j = 1; j <= n; ++j) {
//                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) - g[i - 1][j - 1];
//            }
//        }
//        return dp[m][n];
//    }
//};

//class Solution {
//public:
//    int minPathSum(vector<vector<int>>& g) {
//        int m = g.size(), n = g[0].size();
//        vector<vector<int>> dp(m + 1, vector<int>(n + 1, INT_MAX));
//        dp[0][1] = dp[1][0] = 0;
//        for (int i = 1; i <= m; ++i) {
//            for (int j = 1; j <= n; ++j) {
//                dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + g[i - 1][j - 1];
//            }
//        }
//        return dp[m][n];
//    }
//};
//
////[[1,3,1],[1,5,1],[4,2,1]]
//int main() {
//    Solution d;
//    vector<vector<int>> num = { {1,3,1},{1,5,1},{4,2,1} };
//    cout << d.minPathSum(num) << endl;
//    return 0;
//}

//int getMax(int l, int r) {
//	int k = log(r - 1 + 1) / log(2);
//	return max(dp[i][k], dp[r - (1 << k) + 1][k]);
//}

//int main() {
//	int n, k; cin >> n >> k;
//	vector<int> a;
//	a.push_back(k);
//	for (int i = 0; i <= n; ++i) {
//		int num, x; cin >> num >> x;
//		switch (num) {
//		case 1:
//			ciin >> x; a.push_back(x);
//			break;
//		case 2:
//			cin >> x;
//			for (int i = 0; i < a.size(); ++i) a[i] += x;
//			break;
//		case 3:
//			cin >> x;
//			for (int i = 0; i < a.size(); ++i) a[i] -= x;
//		case 4:
//			sort(a.begin(), a.end());
//			cout << a[a.size() - 1] << endl;
//			a.pop_back();
//			break;
//		}
//	}
//	return 0;
//}

class Solution {
public:
	int bp(vector<vector<int>>& dps,int n,int V) {
		int v = dps.size(), w = dps[0].size();
		vector<vector<int>> dp(n + 1, vectro<int>(m + 1));
		dp[1][0] = dp[0][1] = 1;
		for (int i = 1; i <= n; ++i) {
			for (int j = V; j >= 0; --j) {
				if (j > w) {
					dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w] + v);
				}
			}
		}
		return dp[n][V];
	}
};

int main() {
	SOlution m;
	int n = 5, V = 20;
	int nums = { {1,6},{2,5},{3,8},{5,15},{3,3} };
	cout << m.dps(nums, n, v) << endl;
	return 0;
}